package com.silence.springboot.dao;

import com.mybatisflex.core.paginate.Page;
import com.mybatisflex.core.query.QueryWrapper;
import com.mybatisflex.core.update.UpdateChain;
import com.silence.springboot.entity.UserBaseInfoEntity;
import com.silence.springboot.mapper.UserBaseInfoMapper;
import lombok.RequiredArgsConstructor;
import org.apache.commons.lang3.StringUtils;
import org.springframework.stereotype.Repository;

import java.util.List;

import static com.silence.springboot.entity.table.UserBaseInfoEntityTableDef.USER_BASE_INFO_ENTITY;

/**
 * 用户基础信息表 数据层。
 */
@Repository
@RequiredArgsConstructor
public class UserBaseInfoDao {

    /**
     * 用户基础信息表 Mapper 接口
     */
    private final UserBaseInfoMapper userBaseInfoMapper;

    /**
     * 根据用户id查询用户信息
     *
     * @param loginId 用户id
     * @return 用户信息
     */
    public UserBaseInfoEntity queryUserBaseInfoByUserId(Long loginId) {
        return userBaseInfoMapper.selectOneByQuery(QueryWrapper.create()
                .select()
                .from(USER_BASE_INFO_ENTITY)
                .where(USER_BASE_INFO_ENTITY.LOGIN_ID.eq(loginId))
        );
    }

    /**
     * 根据用户id更新token
     *
     * @param loginId 用户id
     * @param token   token
     */
    public void updateTokenByUserId(Long loginId, String token) {
        UpdateChain.of(UserBaseInfoEntity.class)
                .from(USER_BASE_INFO_ENTITY)
                .set(UserBaseInfoEntity::getToken, token)
                .where(UserBaseInfoEntity::getLoginId).eq(loginId)
                .update();
    }

    /**
     * 分页查询用户基础信息
     *
     * @param pageNum  页码
     * @param pageSize 每页数量
     * @return 用户基础信息
     */
    public Page<UserBaseInfoEntity> page(Integer pageNum, Integer pageSize) {
        return userBaseInfoMapper.paginate(pageNum, pageSize, QueryWrapper.create()
                .select()
                .from(USER_BASE_INFO_ENTITY)
                .where(USER_BASE_INFO_ENTITY.LOGIN_FLAG.eq(1))
        );
    }


    /**
     * 新增或更新用户基础信息
     *
     * @param entity 用户基础信息
     */
    public boolean insertOrUpdate(UserBaseInfoEntity entity) {
        return userBaseInfoMapper.insertOrUpdateSelective(entity) > 0;
    }

    /**
     * 根据id查询用户基础信息
     *
     * @param id 用户基础信息id
     * @return 用户基础信息
     */
    public UserBaseInfoEntity selectOneById(Long id) {
        return userBaseInfoMapper.selectOneById(id);
    }

    /**
     * 删除用户基础信息
     *
     * @param id 用户基础信息id
     */
    public void deleteById(Long id) {
        userBaseInfoMapper.deleteById(id);
    }

    /**
     * 查询用户基础信息列表
     *
     * @param ids 用户基础信息id列表
     * @return 用户基础信息列表
     */
    public List<UserBaseInfoEntity> selectListByIds(List<Long> ids) {
        return userBaseInfoMapper.selectListByIds(ids);
    }

    /**
     * 根据id批量删除用户基础信息
     *
     * @param ids 用户基础信息id列表
     */
    public void deleteBatchByIds(List<Long> ids) {
        userBaseInfoMapper.deleteBatchByIds(ids);
    }

    /**
     * 根据条件查询用户基础信息
     *
     * @param convertEntity 用户基础信息
     * @return 用户基础信息列表
     */
    public Page<UserBaseInfoEntity> selectListByQuery(Integer pageNum, Integer pageSize, UserBaseInfoEntity convertEntity) {
        return userBaseInfoMapper.paginate(pageNum, pageSize, QueryWrapper.create()
                .select()
                .from(USER_BASE_INFO_ENTITY)
                .where(USER_BASE_INFO_ENTITY.LOGIN_FLAG.eq(1))
                .where(USER_BASE_INFO_ENTITY.NAME.like(convertEntity.getName(), StringUtils::isNotBlank))
                .where(USER_BASE_INFO_ENTITY.NICK_NAME.like(convertEntity.getNickName(), StringUtils::isNotBlank))
                .where(USER_BASE_INFO_ENTITY.PHONE.eq(convertEntity.getPhone(), StringUtils::isNotBlank))
                .where(USER_BASE_INFO_ENTITY.EMAIL.eq(convertEntity.getEmail(), StringUtils::isNotBlank))
        );
    }
}
